Abstract: ZL is a C++-compatible language in which high-level constructs, such as classes, are defined using macros over a C-like core language. This approach makes many parts of the language easily customizable. For example, since the class construct can be defined using macros, a programmer can have complete control over the memory layout of objects. Using this capability, a programmer can mitigate certain problems in software evolution such as fragile ABIs (Application Binary Interfaces) due to software changes and incompatible ABIs due to compiler changes. In this paper, we outline the problem of fragile and incompatible ABIs and show how ZL can be used to solve them.

Abstract: This paper deals with embedded systems software and the modification of its architecture and behavior at execution-time. Incautious implementation of such capabilities demands heavy memory and performance overrun. To accomplish such software evolution activities in resource-constrained embedded systems, we propose a component-based run-time evolution infrastructure that reconciles richness of evolution alternatives and performance requirements. Our proposition is based on off-site components reifications, representations of components which allow us to treat evolution concerns remotely and hence to alleviate the workload to be processed by the embedded device. Memory and processor-time resources consumption evaluation on a real-world scenario show the efficiency and pertinence of our approach.

Abstract: Delta modeling is an approach to facilitate automated product derivation for software product lines. It is based on a set of deltas specifying modifications that are incrementally applied to a core product. The applicability of deltas depends on feature-dependent conditions. This paper presents abstract delta modeling, which explores delta modeling from an abstract, algebraic perspective. Compared to previous work, we take a more flexible approach with respect to conflicts between modifications and introduce the notion of conflict resolving deltas. We present conditions on the structure of deltas to ensure unambiguous product generation.

• Arie Middelkoop, S. Doaitse Swierstra and Atze Dijkstra: Iterative Type Inference with Attribute Grammars

• Matthias P. Krieger, Alexander Knapp and Burkhart Wolff: Automatic and Efficient Simulation of Operation Contracts

• Reinhard Wolfinger, Markus Löberbauer, Markus Jahn and Hanspeter Mössenböck: Adding Genericity to a Plug-in Framework

• Tiark Rompf and Martin Odersky: Lightweight Modular Staging: A Pragmatic Approach to Runtime Code Generation and Compiled DSLs

• Zoltan Porkolab and Abel Sinkovics: Domain-specific Language Integration with Compile-time Parser Generator Library

• Kevin Atkinson, Matthew Flatt and Gary Lindstrom: ABI Compatibility Through a Customizable Language

• Juan F. Navas, Jean-Philippe Babau and Jacques Pulou: A Component-based Run-time Evolution Infrastructure for Resource-Constrained Embedded Systems

• Christian Hofer and Klaus Ostermann: Modular Domain-Specific Language Components in Scala

• Dave Clarke, Michiel Helvensteijn and Ina Schaefer: Abstract Delta Modeling

• Uwe Ryssel, Joern Ploennigs and Klaus Kabitzsch: Automatic Variation-Point Identification in Function-Block-Based Models

• Sandro Schulze, Sven Apel and Christian Kästner: Code Clones in Feature-Oriented Software Product Lines

• Julio Sincero, Reinhard Tartler, Daniel Lohmann and Wolfgang Schröder-Preikschat: Efficient Extraction and Analysis of Preprocessor-Based Variability

• Éric Tanter, Philippe Moret, Walter Binder and Danilo Ansaloni: Composition of Dynamic Analysis Aspects

• Thomas Wuerthinger, Walter Binder, Danilo Ansaloni, Philippe Moret and Hanspeter Mössenböck: Applications of Dynamic Code Evolution for Java in GUI Development and Dynamic Aspect-Oriented Programming

• Yuheng Long, Sean Mooney, Tyler Sondag and Hridesh Rajan: Implicit Invocation Meets Safe, Implicit Concurrency

• Mirko Bordignon, Ulrik P. Schultz and Kasper Stoy: Model-based Kinematics Generation for Modular Mechatronic Toolkits

• Weiyu Miao and Jeremy Siek: Incremental Type-Checking for Type-Reflective Metaprograms

• Neville Grech, Julian Rathke and Bernd Fischer: JEqualityGen: Generating equality and hashing methods

Abstract: Plug-in components are a means for making feature-rich applications customizable. Combined with plug-and-play composition, end users can assemble customized applications without programming. If plug-and-play composition is also dynamic, applications can be reconfigured on the fly to load only components the user needs for his current work. We have created Plux.NET, a plug-in framework that supports dynamic plug-and-play composition. The basis for plug-and-play in Plux is the composer which replaces programmatic composition by automatic composition. Components just specify their requirements and provisions using metadata. The composer then assembles the components based on that metadata by matching requirements and provisions. When the composer needs to reuse general-purpose components in different parts of an application, the component model requires genericity. The composer depends on metadata that specify which components should be connected and for general-purpose components those metadata need to be different on each reuse. We present an approach for generic plug-ins with component templates and an implementation for Plux. The general-purpose components become templates and the templates get parameterized when they are composed.

Abstract: While dynamic code evolution in object-oriented systems is an important feature supported by dynamic languages, there is currently only limited support for dynamic code evolution in high-performance, state-of-the-art runtime systems for statically typed languages, such as the Java Virtual Machine. In this tool demonstration, we present the Dynamic Code Evolution VM, which is based on a recent version of Oracle's state-of-the-art Java HotSpot(TM) VM and allows unlimited changes to loaded classes at runtime. Based on the Dynamic Code Evolution VM, we developed an enhanced version of the Mantisse GUI builder (which is part of the NetBeans IDE) that allows adding GUI components without restarting the application under development. Furthermore, we redesigned the dynamic AOP framework HotWave to take advantage of the enhanced dynamic code evolution capabilities. The new version, HotWave2, now supports most AspectJ constructs, including "around()" advice and static cross-cutting. We will demonstrate both the enhanced Mantisse GUI builder as well as HotWave2, weaving several aspects for dynamic analysis in sizable applications at runtime.

Abstract: Operation contracts consisting of pre- and postconditions are a well-known means of specifying operations. In this paper we deal with the problem of operation contract simulation, i.e. determining operation results satisfying the postconditions based on input data supplied by the user; simulating operation contracts is an important technique for requirements validation and prototyping. Current approaches to operation contract simulation exhibit poor performance for large sets of input data or require additional guidance from the user. We show how these problems can be alleviated and describe an efficient as well as fully automatic approach. It is implemented in our tool OCLexec that generates from UML/OCL operation contracts corresponding Java implementations which call a constraint solver at runtime. The generated code can serve as a prototype. A case study demonstrates that our approach can handle problem instances of considerable size.

Abstract: Function-block-based modeling is often used to develop embedded systems, particularly as system variants can be developed rapidly from existing modules. Generative approaches can simplify the handling and development of the resulting high variety of function-block-based models. But they often require the development of new generic models that do not utilize existing ones. Reusing existing models will significantly decrease the effort to apply generative programming. This work introduces an automatic approach to recognize variants in a set of models and identify the variation points and their dependencies within the variants. As result it offers automatically generated feature models and ICCL content to generate the given variants.

CALL FOR PAPERS (txt^?,pdf^?)

---

Ninth International Conference on

Generative Programming and Component Engineering (GPCE'10)

October 10-13, 2010
Eindhoven, The Netherlands
(co-located with SLE 2010)

Sponsored by ACM SIGPLAN.
GPCE'10 proceedings published by ACM Press.
GPCE'10 on twitter: https://twitter.com/gpceconf

---

Important Dates

• Submission of abstracts: Wednesday, May 26, 23:59:59, Apia time
• Submission of papers: Sunday, May 30, 23:59:59, Apia time
• Author notification: July 5, 2010

Scope

Generative and component approaches are revolutionizing software development similar to how automation and components revolutionized manufacturing. Generative Programming (concerning programs that synthesize other programs), Component Engineering (concerning modularity in application design), and Domain-Specific Languages (DSLs) (concerning compact domain-specific notations for expressing programs) are key technologies for automating program development.

The International Conference on Generative Programming and Component Engineering is a venue for researchers and practitioners interested in techniques that, through deploying components and program generation, increase programmer productivity, improve software quality, and shorten the time-to-market of software products. In addition to exploring cutting-edge techniques of generative and component-based software, our goal is to foster further cross-fertilization between the software engineering and the programming languages research communities.

Submissions

Research papers

10 pages in SIGPLAN proceedings style (sigplanconf.cls, see http://www.sigplan.org/authorInformation.htm) reporting original research results that contribute to scientific knowledge in the areas listed below (the PC chair can advise on appropriateness).

Tool demonstrations

Tool demonstrations should present tools that implement generative and component-based software engineering techniques, and are available for use. Any of the GPCE'10 topics of interest are appropriate areas for tool demonstrations. Purely commercial tool demonstrations will not be accepted. Submissions should contain a tool description of 4 pages in SIGPLAN proceedings style (sigplanconf.cls) and a demonstration outline of up to 2 pages text plus 2 pages screen shots. The four page description will, if the demonstration is accepted, be published in the proceedings. The 2+2 page demonstration outline will only be used by the PC for evaluating the submission.

Tutorials and Workshops

Please contact the chairs (chairs@gpce.org) if you would like to organize a tutorial or workshop of interest to the GPCE audience. Tutorials and workshops will be scheduled for Sunday, October 10th, 2010.

Topics

GPCE seeks contributions in software engineering and in programming languages related (but not limited) to:

• Generative programming
  • Reuse, meta-programming, partial evaluation, multi-stage and multi-level languages, step-wise refinement, generic programming
  • Semantics, type systems, symbolic computation, linking and explicit substitution, in-lining and macros, templates, program transformation
  • Runtime code generation, compilation, active libraries, synthesis from specifications, development methods, generation of non-code artifacts, formal methods, reflection
• Generative techniques for
  • Product-line architectures
  • Distributed, real-time and embedded systems
  • Model-driven development and architecture
  • Resource bounded/safety critical systems.
• Component-based software engineering
  • Reuse, distributed platforms and middleware, distributed systems, evolution, patterns, development methods, deployment and configuration techniques, formal methods
• Integration of generative and component-based approaches
• Domain engineering and domain analysis
  • Domain-specific languages including visual and UML-based DSLs
• Separation of concerns
  • Aspect-oriented and feature-oriented programming,
  • Intentional programming and multi-dimensional separation of concerns
• Industrial applications of the above

Submissions must adhere to SIGPLAN's republication policy. Please contact the program chair if you have any questions about how this policy applies to your paper (chairs@gpce.org).

Organization

• General Chair: Eelco Visser (Delft University of Technology, The Netherlands)
• Program Chair: Jaakko Järvi (Texas A&M University, USA)
• Publicity Chair: Giorgios Economopoulos (University of Southampton, UK)

Program Committee

• Sven Apel (University of Passau, Germany)
• Don Batory (University of Texas, USA)
• Martin Bravenboer (LogicBlox, USA)
• Krzysztof Czarnecki (University of Waterloo, Canada)
• Charles Consel (INRIA / LaBRI, France)
• Gabriel Dos Reis (Texas A&M University, USA)
• Ewen Denney (RIACS/NASA Ames, USA)
• Ronald Garcia (Carnegie Mellon University, USA)
• Magne Haveraaen (University of Bergen, Norway)
• Johan Lilius (Åbo Akademi University, Finland)
• Andres Löh (Utrecht University, The Netherlands)
• Mat Marcus (Canyonlands Software Design, USA)
• Marjan Mernik (University of Maribor, Slovenia)
• Klaus Ostermann (University of Marburg, Germany)
• Bruno C. d. S. Oliveira (Seoul National University, Korea)
• Hridesh Rajan (Iowa State University, USA)
• Sukyoung Ryu (Korea Advanced Institute of Science and Technology, Korea)
• João Saraiva (Minho University, Portugal)
• Sibylle Schupp (Hamburg University of Technology, Germany)
• Mirko Viroli (University of Bologna, Italy)
• Alessandro Warth (Viewpoints Research Institute, USA)
• Edwin Westbrook (Rice University, USA)
• Jeremiah Willcock (Indiana University, USA)
• Kwang Yi (Seoul National University, Korea)

CALL FOR TUTORIAL LECTURES

---

Ninth International Conference on

Generative Programming and Component Engineering (GPCE'10)

October 10-13, 2010
Eindhoven, The Netherlands
(co-located with SLE 2010)

Sponsored by ACM SIGPLAN.
GPCE'10 proceedings published by ACM Press.
GPCE'10 on twitter: https://twitter.com/gpceconf

---

Important dates

• Submission of tutorial proposals: Tuesday, July 6, 2010, 23:59:59
• Author notification: August 6, 2010

Scope

As an experiment, GPCE and SLE organize a joint tutorial day on Sunday, October 10.

The day will consist of a single plenary track with about six lectures about topics of interest to the audience of GPCE and SLE.

The lectures will be about an hour in length; much longer than a regular conference talk, but much shorter than the customary half or even full day tutorials at other conferences.

In contrast to research talks, tutorials do not (have to) present original new research material, but should rather focus on putting research into perspective for a broader audience.

In contrast to longer tutorials, these lectures cannot be very interactive or rely on the audience participating by using tools. Rather they should aim to be 'keynote' style presentations, emphasizing the essence (but not avoiding depth).

Another difference is that we will not charge separately for each tutorial, as this appears to be the reason for low attendance of tutorials at academic conferences. We will charge a single, low fee for the entire day that gives access to all tutorials and the FOSD workshop that will be held in parallel. We hope that this will ensure high impact of the tutorials. Tutorial presenters get free admission to the tutorials day, but due to the low fee we will not be able to provide a honorarium; if the day is successful, we will consider sharing any profits with tutorial presenters.

Submission

If you are interested in presenting a tutorial at GPCE/SLE, please send a short proposal (about two pages) to e.visser@tudelft.nl by July 6, 2010. The proposal should consist of

1. title
2. abstract (250 words)
3. name of presenter
4. short bio (250 words)
5. brief outline of tutorial
6. relevance for GPCE/SLE audience

Items 1 to 4 should be usable on the website.

We will make a selection of tutorials based on relevance (topic-wise) for the conference and expected interest in the tutorial. Tutorial proposers will be notified of the decision by August 6, 2010.

Abstract: Some limitations of object-oriented mechanisms are known to cause code clones (e.g., extension using inheritance). Novel programming paradigms such as feature-oriented programming (FOP) aim at alleviating these limitations. However, it is an open issue whether FOP is really able to avoid code clones or whether it even facilitates (FOP-specific) clones. To address this issue, we conduct an empirical analysis on ten feature-oriented software product lines with respect to code cloning. We found that there is a considerable amount of clones in feature-oriented software product lines and that a large fraction of these clones is FOP-specific (i.e., caused by limitations of feature-oriented mechanisms). Based on our results, we initiate a discussion on the reasons for FOP-specific clones and on how to cope with them.

Abstract: Aspect-oriented programming provides a convenient high-level model to define several kinds of dynamic analyses, in particular thanks to recent advances in exhaustive weaving in core libraries. Casting dynamic analyses as aspects allows the use of a single weaving infrastructure to apply different analyses to the same base program, simultaneously. However, even if dynamic analysis aspects are mutually independent, their mere presence perturbates the observations of others: this is due to the fact that aspectual computation is potentially visible to all aspects. Because current aspect composition approaches do not address this kind of computational interference, combining different analysis aspects yields at best unpredictable results. It is also impossible to flexibly combine various analyses, for instance to analyze an analysis aspect. In this paper we show how the notion of execution levels makes it possible to effectively address these composition issues. In order to realize this approach, we explore the practical and efficient integration of execution levels in a mainstream aspect language, AspectJ. We report on a case study of composing two out-of-the-box analysis aspects in a variety of ways, highlighting the benefits of the approach.

Ninth International Conference on

Generative Programming and Component Engineering (GPCE'10)

October 10-13, 2010
Eindhoven, The Netherlands
(co-located with SLE 2010)

Sponsored by ACM SIGPLAN.
GPCE'10 proceedings published by ACM Press.
GPCE'10 on twitter: https://twitter.com/gpceconf

General Chair:

• Eelco Visser (Delft University of Technology, The Netherlands)

Program Chair:

• Jaakko Järvi (Texas A&M University, United States of America)

Program Committee Members:

• Sven Apel (University of Passau, Germany)
• Don Batory (University of Texas, USA)
• Martin Bravenboer (LogicBlox, USA)
• Krzysztof Czarnecki (University of Waterloo, Canada)
• Charles Consel (INRIA / LaBRI, France)
• Gabriel Dos Reis (Texas A&M University, USA)
• Ewen Denney (RIACS/NASA Ames, USA)
• Ronald Garcia (Carnegie Mellon University, USA)
• Magne Haveraaen (University of Bergen, Norway)
• Johan Lilius (Åbo Akademi University, Finland)
• Andres Löh (Utrecht University, The Netherlands)
• Mat Marcus (Canyonlands Software Design, USA)
• Marjan Mernik (University of Maribor, Slovenia)
• Klaus Ostermann (University of Marburg, Germany)
• Bruno C. d. S. Oliveira (Seoul National University, Korea)
• Hridesh Rajan (Iowa State University, USA)
• Sukyoung Ryu (Korea Advanced Institute of Science and Technology, Korea)
• João Saraiva (Minho University, Portugal)
• Sibylle Schupp (Hamburg University of Technology, Germany)
• Mirko Viroli (University of Bologna, Italy)
• Alessandro Warth (Viewpoints Research Institute, USA)
• Edwin Westbrook (Rice University, USA)
• Jeremiah Willcock (Indiana University, USA)
• Kwang Yi (Seoul National University, Korea)

Treasurer:

• Alexander Serebrenik (Eindhoven University of Technology, The Netherlands)

Publicity Chair:

• Giorgios Economopoulos (University of Southampton, United Kingdom)

Steering Committee:

• Julia Lawall (DK), Chair (2008-)
• Eelco Visser (NL), (2008-)
• Charles Consel Chair (FR), (2007-)
• Stanislaw Jarzabek (SG), (2005-)
• Jeremy Siek (US) (2008-)

Sunday, October 10

All Sunday activities will take place in Academisch Genootschap Eindhoven. The tutorials will take place in the Meerlezaal, FOSD in Haardkamer. Small groups can convene for informal "birds of feather" sessions in the Terraskamer.

FOSD

Tutorial Lectures

8:30	Registration
8:50	Opening
9:00	Tutorial 1 - Project Fortress: A Growable Language for Scientists and Engineers [pdf?]
	Sukyoung Ryu
10:00	Break
10:30	Tutorial 2 - Mega-Modeling Software Language Artifacts [pdf?]
	Jean-Marie Favre, Dragan Gašević, Ralf Lämmel
11:30	Tutorial 3 - Embedded Domain-Specific Language Implementation using Dependent Types [pdf?]
	Edwin Brady
12:30	Lunch
13:30	Tutorial 4 - Agile and Efficient Domain-Specific Languages using Multi-Stage Programming in Java Mint [pdf?, ppt?]
	Mathias Ricken, Edwin Westbrook, Walid Taha
14:30	Tutorial 5 - Ontologies and Software Language Engineering [pdf?]
	Dragan Gašević, Fernando Silva Parreiras, Tobias Walter
15:30	Break
16:00	Tutorial 6 - Language Definition and Extension with MPS [pdf?]
	Markus Völter
17:00	End

Monday, October 11

SLE doctoral symposium

GPCE (with GPCE keynote)

8.45	Opening
9.00-10.00	Keynote (Session 1)
	Ralf Lämmel: The Hitchhiker's Guide to Software Languages
10.00-10.30	Coffee
10.30-12.00	Session 2 Separation of Concerns 1
	Session Chair: Sven Apel
	Dave Clarke, Michiel Helvensteijn and Ina Schaefer: Abstract Delta Modeling
	Uwe Ryssel, Joern Ploennigs and Klaus Kabitzsch: Automatic Variation-Point Identification in Function-Block-Based Models
	Julio Sincero, Reinhard Tartler, Daniel Lohmann and Wolfgang Schröder-Preikschat: Efficient Extraction and Analysis of Preprocessor-Based Variability
12.00-13.30	Lunch
13.30-15.00	Session 3 Languages and Language Technology 1
	Session Chair: Edwin Westbrook
	Arie Middelkoop, S. Doaitse Swierstra and Atze Dijkstra: Iterative Type Inference with Attribute Grammars
	Matthias P. Krieger, Alexander Knapp and Burkhart Wolff: Automatic and Efficient Simulation of Operation Contracts
	Yuheng Long, Sean Mooney, Tyler Sondag and Hridesh Rajan: Implicit Invocation Meets Safe, Implicit Concurrency
15.00-15.30	Coffee
15.30-17.00	Session 4 Components
	Session Chair: Zoltan Porkolab
	Juan F. Navas, Jean-Philippe Babau and Jacques Pulou: A Component-based Run-time Evolution Infrastructure for Resource-Constrained Embedded Systems
	Christian Hofer and Klaus Ostermann: Modular Domain-Specific Language Components in Scala
	Reinhard Wolfinger, Markus Löberbauer, Markus Jahn and Hanspeter Mössenböck: Adding Genericity to a Plug-in Framework
17.30-19.00	Reception

Tuesday, October 12

GPCE & SLE (with joint keynote)

8.45	Opening
9.00-10.00	Keynote (Session 1)
	Martin Erwig: A Language for Software Variation Research
10.00-10.30	Coffee
10.30-12.00	Session 2 Separation of Concerns 2
	Session Chair: Jeremy Siek
	Sandro Schulze, Sven Apel and Christian Kästner: Code Clones in Feature-Oriented Software Product Lines
	Éric Tanter, Philippe Moret, Walter Binder and Danilo Ansaloni: Composition of Dynamic Analysis Aspects
	Thomas Wuerthinger, Walter Binder, Danilo Ansaloni, Philippe Moret and Hanspeter Mössenböck: Applications of Dynamic Code Evolution for Java in GUI Development and Dynamic Aspect-Oriented Programming
12.00-13.30	Lunch
13.30-15.00	Session 3 Languages and Language Technology 2
	Session Chair: Charles Consel
	Tiark Rompf and Martin Odersky: Lightweight Modular Staging: A Pragmatic Approach to Runtime Code Generation and Compiled DSLs
	Zoltan Porkolab and Abel Sinkovics: Domain-specific Language Integration with Compile-time Parser Generator Library
	Kevin Atkinson, Matthew Flatt and Gary Lindstrom: ABI Compatibility Through a Customizable Language
15.00-15.30	Coffee
15.30-17.00	Session 4 Generation
	Session Chair: Klaus Ostermann
	Mirko Bordignon, Ulrik P. Schultz and Kasper Stoy: Model-based Kinematics Generation for Modular Mechatronic Toolkits
	Weiyu Miao and Jeremy Siek: Incremental Type-Checking for Type-Reflective Metaprograms
	Neville Grech, Julian Rathke and Bernd Fischer: JEqualityGen: Generating equality and hashing methods
18.00-22.00	Conference banquet -- DAF Museum

Wednesday, October 13

SLE (with SLE keynote)

8.45	Opening
9.00-10.00	Keynote (Session 1)
10.00-10.30	Coffee
10.30-12.00	Session 2
12.00-13.30	Lunch
13.30-15.00	Session 3
15.00-15.30	Coffee
15.30-17.00	Session 4

SLE and GPCE registration

Registration is live now! The early registration deadline has been extended to September 15, 2010.

Click here to go to the actual registration page.

	Early	Late	On-site
GPCE
ACM	350	400	450
Non-ACM	400	450	500
Student	275	325	375
SLE*	125	125	125
Workshop FOSD + tutorials*	90	90	90
Doctoral Symposium*	40	40	40

* (registration is possible only in combination with GPCE)

Hotels

During the registration process, it is possible to reserve a room in the Crown Inn Hotel Eindhoven and the Holiday Inn Eindhoven. In case neither of these hotels meet your requirements, we have identified several alternatives:

Van der Valk Hotel

• From € 102.50 pp
• Address: Aalsterweg 322, Eindhoven
• Tel : +31 (0)40 211 60 33
• Distance to Town Centre: 3.5 km
• Distance to TUE: 4.2 km

Hotel-o-theek (Budget Hotel)

• From € 26.- pp
• Address: Wilhelminaplein 4, Eindhoven
• Tel: +31(0)402448992
• Distance to Town Centre: 0.2 km
• Distance to TUE: 2.1 km

Bed and Breakfast Eindhoven

• From € 22.50 pp
• Address: Boschdijk 165, Eindhoven
• Tel: +31(0)40-2133257 or Mobile: +31(0)6-53871400
• Distance to Town Centre: 1 km
• Distance to TUE: 1.7 km

GPCE 2010 will be held in the Auditorium of the Eindhoven University of Technology, co-located with SLE 2010

The Eindhoven University of Technology was founded in the 1950s on a patch of uncultivated land near the centre of town. Due to this fortunate circumstance, the university campus is now right in the middle of the fifth largest city in the Netherlands. This means that the railway station, the conference hotels, and other facilities are all within walking distance of the campus, and that during your stay you will have easy access to everything Eindhoven has to offer. The FOSD workshop will take place in a separate location, the Academisch Genootschap. This building is located a short distance from the campus. The workshop dinner will also be held at this location. It should be noted that one the day of the workshop, October 10 2010, the annual Eindhoven Marathon will take place. The Eindhoven city centre will likely be very crowded during this event.

Travel

Eindhoven is located in the south of the Netherlands and can be reached by air, rail, and road.

Planes

The main airport of the Netherlands is Schiphol near Amsterdam. All major airlines fly to Schiphol, click here for a current overview.

Schiphol has direct a train connection to Eindhoven. The journey takes about 1.5 hours, with trains running twice an hour. The Eindhoven central station is within walking distance of both conference hotels and the conference venue. Taxis can be found at both exits of the station.

Eindhoven itself has a small international airport Eindhoven Airport, with an increasing number of direct connections to destinations in Europe. Click here for an up-to-date list of destinations.

The airport is about a 15 minute drive from the city centre. You can make this trip by bus or by taxi. The airport website has information on the bus connection, and also offers the possibility to make taxi reservations. Bus tickets can be bought on the bus from the driver, or at the AKO-shop (news agent) in the arrivals hall of Eindhoven Airport (opening hours: Mon-Fri 07.00 – 21.00; Sat 07.00 – 14.30; Sun 09.00 -20.30).

Trains

Eindhoven is part of the intercity network of the Dutch railways and has direct rail connections with Amsterdam, Den Haag, Rotterdam, Utrecht, Heerlen and Maastricht, for example.

To plan your train trip inside the Netherlands, you can consult the planner on the website of the Dutch railways (NS) or on the 9292ov site. For international train connections you can check the ns highspeed site or the site of the Deutsche Bahn.

Automobiles

Eindhoven is situated at the junction of A2 and A67 motorways, see the TU/e website for a map and directions. From all motorways to and around Eindhoven (A2, A58, A67 en A270) follow the road signs with 'Centrum' until 'Universiteit' is indicated. There is sufficient parking space on campus.

Directions to the Auditorium

The Technische Universiteit Eindhoven campus is situated in the centre of Eindhoven. The venue, the Auditorium building, is marked "AUD" on the campus map.

Abstract: Smooth integration of domain-specific languages into a general purpose host language requires absorbing of domain code written in arbitrary syntax. The integration should cause minimal syntactical and semantic overhead and introduce minimal dependency on external tools. In this paper we discuss a DSL integration technique for the C++ programming language. The solution is based on compile-time parsing of the DSL code. The parser generator is a C++ template metaprogram reimplementation of a runtime Haskell parser generator library. The full parsing phase is executed when the host program is compiled. The library uses only standard C++ language features, thus our solution is highly portable. As a demonstration of the power of this approach, we present a highly efficient and type-safe version of printf and the way it can be constructed using our library. Despite the well known syntactical difficulties of C++ template metaprograms, building embedded languages using our library leads to self-documenting C++ source code.

Abstract: The CPP is the dominant tool of choice for the implementation of variability in large-scale configurable software. Linux, probably the most-configurable piece of software ever, employs more than 10,000 preprocessor variables for this purpose. However, this de-facto variability tends to be ``hidden in the code''; which on the long term leads to varibility defects, such as dead code or inconsistencies with respect to the intended (modelled) variability of the software. This calls for tool support for the efficient extraction of (and reasoning over) CPP-based variability.

We suggest a novel approach to extract CPP-based variability. Our tool transforms CPP-based variability in O(n) complexity into a propositional formula that ``mimics'' all valid effects of conditional compilation and can be queried with standard SAT or BDD packages.

Our evaluation results demonstrate the scaleability and practicability of the approach. A dead-block-analysis on the complete Linux source tree takes less than 15 minutes; we thereby have revealed 4 defects, 2 of which meanwhile have been confirmed as new (and long-lasting) bugs.

Abstract: Writing correct and efficient concurrent programs still remains a challenge. Explicit concurrency is difficult, error prone, and creates code which is hard to maintain and debug. This type of concurrency also treats modular program design and concurrency as separate goals, where modularity often suffers.

To solve these problems, we are designing a new language that we call Panini. In this paper, we focus on Panini's asynchronous, typed events, which reconcile the modularity goal promoted by the implicit invocation design style with the concurrency goal of exposing potential concurrency between the execution of subjects and observers.

Since modularity is improved and concurrency is implicit in Panini, programs are easier to reason about and maintain. Furthermore, races and deadlocks are avoided entirely, yielding programs with a guaranteed sequential semantics.

To evaluate our language design and implementation we show several examples of its usage as well as an empirical study of program performance.

We found that not only is developing and understanding Panini programs significantly easier compared to standard concurrent object-oriented programs, but performance of Panini programs is also comparable to their equivalent hand-tuned versions written using Java's fork-join framework.

Important Dates

• Tutorial Proposals July 6, 2010
• Submission of abstracts: Wednesday, May 26, 23:59:59, Apia time
• Submission: Sunday, May 30, 23:59:59, Apia time
• Notification: July 5, 2010
• Camera Ready Papers: ?
• Conference: October 10-13, 2010

Abstract: Garcia introduces a calculus for type-reflective metaprogramming that provides much of the power and flexibility of C++ templates and solves many of its problems. However, one of the problems that remains is that the residual program is not type checked until after meta computation is complete. Ideally, one would like the type system of the metaprogram to also guarantee that the residual program will type check, as is the case in MetaML. However, in a language with type-reflective metaprogramming, type expressions in the residual program may be the result of meta computation, making the MetaML guarantee next to impossible to achieve.

In this paper we offer an approach to detecting errors earlier without sacrificing flexibility: we incrementally type check code fragments as they are created and spliced together during meta computation. The incremental type system is a variant of the gradual type system of Siek and Taha, in which we use type variables to represent type expressions that are not yet normalized and a new dynamic variation on existential types to represent residual code fragments. A type error in a code fragment is treated as a run-time error of the meta computation. We show that the incremental type checker can be implemented efficiently and we prove that if a well-typed metaprogram generates a residual program, then the residual program is also well-typed.

Abstract: Type inference is the process of constructing a typing derivation while gradually discovering type information. During this process, inference algorithms typically make subtle decisions based on the derivation constructed so far.

Because a typing derivation is a decorated tree we aim to use attribute grammars as the main implementation tool. Unfortunately, we can neither express iteration, nor express decisions based on intermediate derivations in such grammars.

Here, we present the language |rulerfront|, a conservative extension to ordered attribute grammars, that deals with the aforementioned problems. We show why this extension is suitable for the description of constraint-based inference algorithms.

Abstract: Manually implementing equals (for object comparisons) and hashCode (for object hashing) methods in large software projects is tedious and error-prone. This is due to many special cases, such as field shadowing, comparison between different types, or cyclic object graphs. Here, we present JEqualityGen, a source code generator that automatically derives implementations of these methods.

JEqualityGen proceeds in two states: it first uses source code reflection in MetaAspectJ to generate aspects that contain the method implementations, before it uses weaving on the bytecode level to insert these into the target application. JEqualityGen generates not only correct, but efficient source code that on a typical large-scale Java application exhibits a performance improvement of more than two orders of magnitude in the equality operations generated, compared to an existing system based on runtime reflection. JEqualityGen achieves this by generating runtime profiling code that collects data. This enables it to generate optimised method implementations in a second round.

Ralf Lämmel is Professor of Computer Science at University of Koblenz-Landau. In his career, he also served at Microsoft Corp., Free University of Amsterdam, Dutch Center for Mathematics and Computer Science (CWI), and University of Rostock. Ralf Lämmel's speciality is "software language engineering" but he is generally interested in themes that combine software engineering and programming languages. Ralf Lämmel is one of the founding fathers of the international summer school series GTTSE-Generative and Transformational Techniques on Software Engineering and the SLE conference (Software Language Engineering). Invited talk The Hitchhiker's Guide to Software Languages

Martin Erwig will present this year's joint GPCE/SLE keynote. Martin Erwig is Professor of Computer Science at Oregon State University where he has been teaching since 2000. He received his Ph.D. and Habilitation in Computer Science from the University of Hagen in Germany. He is the author or co-author of two books and over 90 peer-reviewed publications, for which he received several best paper awards. His research interests center around the design of domain-specific languages, mainly within the contexts of functional programming and visual languages. Invited talk A Language for Software Variation Research

Abstract: Software engineering demands generality and abstraction, performance demands specialization and concretization. Generative programming can provide both, but developing high-quality program generators takes a large effort, even if a multi-stage programming language is used.

We present lightweight modular staging, a library-based multi-stage programming approach that breaks with the tradition of syntactic quasi-quotation and instead uses only types to distinguish between binding times. Through extensive use of component technology, lightweight modular staging makes an optimizing compiler framework available at the library level, allowing programmers to tightly integrate domain-specific abstractions and optimizations into the generation process.

We argue that lightweight modular staging enables a form of language virtualization, i.e. allows to go from a pure-library embedded language to one that is practically equivalent to a stand-alone implementation with only modest effort.

A Language for Software Variation Research

Martin Erwig, Oregon State University, USA

Managing variation is an important problem in software engineering that takes different forms, ranging from version control and configuration management to software product lines. In this talk, I present our recent work on the choice calculus, a fundamental representation for software variation that can serve as a common language of discourse for variation research, filling a role similar to lambda calculus in programming language research.

After motivating the design of the choice calculus and sketching its semantics, I will discuss several potential application areas.

Abstract: Modular robots are mechatronic devices that enable the construction of highly versatile and flexible robotic systems that can dynamically modify their assembled mechanical structure. The key feature that enables this dynamic modification is the capability of the individual modules to connect to each other in multiple ways and thus generate a number of different mechanical systems, in contrast with the monolithic, fixed structure of conventional robots. The mechatronic flexibility, however, complicates the development of models and programming abstractions for modular robots, since manually describing and enumerating the full set of possible interconnections is tedious and error-prone for real-world robots.

In order to allow for a general formulation of spatial abstractions for modular robots and to ensure correct and streamlined generation of code dependent on mechanical properties, we have developed the Mechatronics Description Language (MDL). MDL is a domain-specific language, which can model the kinematic structure of individual robot modules and declaratively describe their possible interconnections, rather than requiring the user to enumerate them in their entirety. From this description, the MDL compiler generates the code that is needed to simulate the resulting robots within Webots, a widely used commercial robot simulator, and the software component needed for spatial structure computations by a virtual machine-based runtime system, which we have developed and use for programming physical modular robots.

Abstract: Programs in domain-specific embedded languages (DSELs) can be represented in the host language in different ways, for instance implicitly as libraries, or explicitly in the form of abstract syntax trees. Each of these representations has its own strengths and weaknesses. The implicit approach has good composability properties, whereas the explicit approach allows more freedom in making syntactic program transformations.

Traditional designs for DSELs fix the form of representation, which means that it is not possible to choose the best representation for a particular interpretation or transformation. We propose a new design for implementing DSELs in Scala which makes it easy to use different program representations at the same time. It enables the DSL implementor to define modular language components and to compose transformations and interpretations for them.

Please print a poster and display it in your institution to help advertise the conference.

The Hitchhiker's Guide to Software Languages

Ralf Lämmel, University of Koblenz-Landau, Germany.

There is only that much space in the CS curriculum, and there are always new subjects that should be accommodated by the curriculum. For instance, in our community, we would want all graduates to leave university with a modest background in technical spaces, software languages, and meta-programming; also, with conceptually informed and reasonably timeless skills to efficiently master related programming techniques and technologies. In reality, the curricula of few CS departments meet this expectation.

In this talk, I will discuss such curricula-related expectations of our community and the suboptimal situation at CS departments—as I perceive them. More importantly, I will allude to a revision of the CS curriculum that could optimize matters and may stand a chance for mid-term adoption.

Acknowledgements

I gratefully acknowledge collaboration with Jean-Marie Favre (OneTree Technologies, Luxembourg) and Dragan Gašević (Athabasca University, Canada) on the subject of this talk.

Extended abstract: pdf^?

Project Fortress: A Growable Language for Scientists and Engineers

Sukyoung Ryu

Abstract

We can think of a programming language as a vocabulary of words and a set of rules that define how to combine words into meaningful constructs. Creating a vocabulary and a set of rules that allow programmers to express their ideas clearly and concisely is one of the main goals of language design. However, it is difficult to anticipate the vocabulary and the set of rules that are suitable for solving various problems. It often depends on domain-specific applications, new hardware platforms, and any unexpected feature requests. Therefore, a language should grow over time to accommodate the changing needs of its users.

Fortress is a new programming language designed for growth by community instead of a single core team. It provides mathematical syntax to enable scientists and engineers to write programs in a notation they are accustomed to. It also provides built-in support for parallel programming. Moreover, its macro system allows for the language growth by extending the syntax and semantics of Fortress.

In designing Fortress, we have adopted the following design strategy: “Whenever possible, implement a proposed language feature in a library rather than building it into the compiler.” For this approach to work, library writers must have substantial flexibility and control over both syntax and semantics. By designing the language for growth, we are designing it for community participation and development. Hence, we have made Project Fortress open source, and are collaborating on its development with many groups and individuals all over the world.

Please come take it for a spin, or pitch in and help us grow!

Author biography

Sukyoung Ryu is an Assistant Professor at the Computer Science Department of KAIST (Korea Advanced Institute of Science and Technology). Before joining KAIST in December 2009, she worked as a Member of Technical Staff in Sun Microsystems Laboratories, where she worked on formally designing and developing the Fortress programming language. Before that, she was a Research Associate in Computer Science at Harvard, where she worked on the Debugging Everywhere project. She received her Ph.D. (2001), M.S. (1996), and B.S. (1995), in Computer Science from KAIST. Her most recent research focuses on developing language features that are both useful in practice and proven to be sound. She led the effort to construct the core calculi of the Fortress language, to improve the Fortress prose specification, and to build a full-fledged parser for Fortress that runs entirely on the JVM.

Download slides as pdf.

(Mega)modeling Software Language Artifacts

Jean-Marie Favre, Dragan Gašević, Ralf Lämmel

Description

Modern software is typically made of heterogeneous sets of software artifacts including for instance databases, programs, transformations, grammars, models and metamodels, compilers, interpreters, formats, ontologies, frameworks, APIs, schemas, configuration files, makefiles, etc. In practice particular languages, tools, implementations, and standards are used such as SQL DDL, Saxon, XLST, Java, Hibernate, XSD, OWL, DOM, Antlr, UML, XMI, Ecore, Awk, and so on. In the absence of a conceptual framework it is difficult to understand the relationships between these software artifacts, if any. The goal of this tutorial is to provide such a framework, showing that the similarity and relationships between techniques can be modeled at a high level of abstraction, and even more importantly that recurring patterns occur in such models. Some of these patterns, for instance those involving “bridges” between technologies, would be really difficult to grasp without a proper conceptualization. As a result software engineers and researchers usually find it hard to understand the intricacies of technologies that are out of their area of expertise and it is more than likely that they do not realize the analogies that exist between heterogeneous technologies. This tutorial aims to unveil these recurring patterns and to show participants coming from different horizons how to model the technologies they design or work with in an uniform way and how to situate them into the overall software language landscape.

In the first part of the tutorial, the notions of software languages and technical spaces are briefly presented with a special emphasis on their unifying character. Then fundamental relations such RepresentationOf and ElementOf are introduced forming the basis of a (mega)modeling framework. Recurrent patterns based on these relations are then presented, allowing to describe for instance the “conformance” relation between let’s say a program and a grammar, an xml file and an xsd schema, or an uml model and its metamodel, etc. More complex patterns such as bridges between technologies (e.g. XML <==> Relational, OO <==> XML, etc.) are defined following the same approach. Though this notion of bridges seems easy to grasp informally at the first sight, it often leads to a rather large and complex set of technologies that are hard to understand and compare without an appropriate framework.

In the second part of the tutorial, the use of (mega)modeling framework is illustrated through its application in three different technical spaces: Grammarware, Modelware and Ontologyware. Concrete examples of various degree of complexity are provided in each case, with again an emphasis on similarities between technical spaces. The hope of this approach is that it should be possible for someone with some knowledge in technical spaces (let’s say grammarware) to improve significantly his or her comprehension about another space (let’s say ontologyware), and this by virtue of analogy. It is our believe that the (mega)modeling approach, by raising the level of abstraction and focusing on essential software language concepts, enables both to better understand complex structures involving many heterogeneous software artifacts, but also to better apprehend new technologies coming from other spaces.

Author bios

Jean-Marie Favre is a software anthropologist and a software language archeologist. He is principal scientist at One Tree Technologies. He has published numerous papers and coedited a book (in French) Beyond MDA: Model Driven Engineering. He has given tutorials and keynotes in more than dozen of international events and summer schools and has organized various national and international events. His research interests include software language engineering, software linguistics, software evolution and reverse engineering, model driven engineering and research 2.0.

Dragan Gašević is a Canada Research Chair in Semantic Technologies and an Associate Professor in the School of Computing and Information Systems at Athabasca University. His research interests include semantic technologies, software language engineering, technology-enhanced learning, and service- oriented architectures. He has (co-)authored numerous research papers and is a led author of the book "Model Driven Engineering and Ontology Development." He has given tutorials at many well-known conferences such as WWW, ISWC, and CAiSE.

Ralf Lämmel is Professor of Computer Science at University of Koblenz-Landau. In his career, he also served at Microsoft Corp., Free University of Amsterdam, Dutch Center for Mathematics and Computer Science (CWI), and University of Rostock. Ralf Lämmel is generally interested in the combination of software engineering and programming languages. Together with the other tutorial speakers and further researchers, he is one of the founding fathers of the SLE conference. He is one of the founding fathers of the summer school series GTTSE--Generative and Transformational Techniques on Software Engineering.

Download slides as pdf.

Embedded Domain-specific Language Implementation using Dependent Types

Edwin Brady

Abstract

Domain-specific languages (DSLs) are programming languages designed for solving problems in a particular domain. By providing suitable abstractions, they allow experts to focus on solving high-level problems without being concerned with low-level programming details. Embedded domain-specific languages (EDSLs) are an emerging implementation technique, in which features of a host language, for example parsing or code generation, are exploited by the DSL implementation. In this way, EDSLs can be implemented much more rapidly than their standalone equivalents and can take advantage of compiler optimisations and other implementation effort in the host.

Dependent types allow types to be predicated on values. Using dependent types, a programmer can ascribe a precise type to a program, for example that concatenating lists of length n and m yields a list of length n + m, or that sorting a list of length n yields a list of length n which is a permutation of its input satisfying a given ordering. In this way, types can be viewed as a form of specification, verified by the type checker.

Using a dependently typed language as the host for an EDSL brings additional benefits. Not only can we reuse the host language’s parser and code generator, we can exploit its type system to express properties of the EDSL and guarantee their correctness. In this tutorial I will introduce I DRIS, a dependently typed functional programming language. I will give practical examples of dependently type programs, culminating in the construction of an EDSL for network protocol implementation.

Author biography

Edwin Brady is a SICSA Advanced Research Fellow in Computer Science at the University of St Andrews, where he has worked since receiving his PhD from the University of Durham in 2005. His research interests include functional programming with dependent types, type theory, program generation and programming language design and implementation. His previous work has included compilation and optimisation techniques for dependently typed functional programming languages. This has important applications in the verification of safety-critical systems; he has also been closely involved with the Hume project (http://www.hume-lang.org/), applying dependent type systems to the correct implementation of safety-critical embedded systems with limited memory. He is the main developer of I DRIS (http://www.idris-lang.org/), a functional language with dependent types intended for systems programming, and contributes to the development of Epigram (http://www.e-pig.org/). His recent work has focused on the practical applications of dependently typed programming, using I DRIS to implement domain-specific languages for verified network protocols, data formats, and resource aware systems in general.

Download slides as pdf.

Agile and Efficient Domain-Specific Languages using Multi-stage Programming in Java Mint

Mathias Ricken, Edwin Westbrook, Walid Taha

Abstract

Domain-specific languages (DSLs) are a powerful productivity tool because they allow domain experts, who are not necessarily programming experts, to quickly develop programs. DSL implementations have unique constraints for programming languages because they must be efficient, in order to ensure high productivity, but they must also be agile, in order to meet the rapidly changing demands of their domains. In this tutorial we show how multi-stage programming (MSP) can be used to build staged interpreters, which combine the agility of interpreters with the efficiency of compilers. The tutorial is conducted in Java Mint, an multi-stage Java based on recent work incorporating MSP into imperative object-oriented languages. In the first half of the tutorial, we introduce MSP by demonstrating how to write a staged interpreter for a number of basic language constructs, such as recursive functions, conditionals, and let expressions. In the second half, we extend our staged interpreter to take advantage of several well-known compiler optimizations, including type inference, constant folding, and static parallel loop scheduling. We highlight the opportunities afforded by using MSP with object-oriented design to quickly create efficient DSL implementations.

Author bios

Mathias Ricken is a doctoral candidate in the Programming Languages Team at Rice University and one of the principal developers of the DrJava integrated development environment. His research interests include concurrent programming, extending the Java language, and computer science education. He is the developer of the Concutest concurrent unit testing framework and has created various experimental extensions of Java to address, for instance, programming with meta-data. Currently, Mathias is contributing to Java Mint, a multi-stage extension of Java that allows safe and expressive statically typed program generation and specialization in an imperative language setting.

Edwin Westbrook is a post-doctoral researcher at Rice University. His primary interests are in developing techniques for implementing and verifying properties of domain-specific languages (DSLs). He has worked on a number of projects in this area, including: Cinic, a type theory for building machine-checked proofs of properties of DSLs using a new approach to higher-order abstract syntax; Java Mint, a multi-stage version of Java used for efficient implementations of DSLs; and Acumen, a DSL for designing cyber-physical systems.

Walid Taha is an professor at Halmstad University. His current interest is in modeling and simulation of cyberphysical systems. He was the principal investigator on a number of research awards and contracts from the National Science Foundation (NSF), Semi-conductor Research Consortium (SRC), and Texas Advanced Technology Program (ATP). He received an NSF CAREER award to develop Java Mint. He is the principle designer Java Mint, Acumen, MetaOCaml, and the Verilog Preprocessor. He founded the ACM Conference on Generative Programming and Component Engineering (GPCE), the IFIP Working Group on Program Generation (WG 2.11), and the Middle Earth Programming Languages Seminar (MEPLS). In 2009, he chaired the IFIP Working Conference on Domain Specific Languages (DSLs).

Download slides in pdf or ppt.

Ontologies and Software Language Engineering

Dragan Gašević, Fernando Silva Parreiras, Tobias Walter

Abstract

Trying to advance the current practices for sharing data, resources and knowledge on the Web, the research community has been researching challenges around the idea of the Semantic Web. The central component of the Semantic Web are ontologies, commonly defined as formal and explicit definitions of shared domain conceptualizations. To have an interoperable and standardized set of technologies, the Semantic Web research offered a stack of standards and tools including automated reasoners and ontology languages, i.e., languages to describe formally a domain of discourse. This stack of standards and tools is popularly called semantic technologies. Among ontology languages, the Web Ontology Language (OWL) [4] is the most prominent.

Mainly, due to the similarities in the design of OWL and object-oriented languages, the research community started exploring a potential synergy. Indeed, OWL provides important features complementary to UML class-based modeling and OCL that improve software languages: it allows different ways of describing classes; it handles these descriptions as first-class entities; it provides additional constructs like transitive closure for properties; and it enables dynamic classification of objects based upon class descriptions.

The most notable work has been done on integrating ontologies and model-driven engineering, especially, for the tasks related to model-driven language engineering. As the OWL language is based on description logic, standard ontology reasoners can be used for various types of processing of software languages such as consistency checking, constraint validation, and query processing and with applications in different software engineering areas such as component-based software development, software product lines, or requirements engineering. For example, the knowledge encoded in OWL evolves independently of the execution logic, i.e., developers maintain class descriptions in the ontology and not in the software. Moreover, developers may use class descriptions to semantically query the domain. Semantic query plays an important role where shared terminologies, interoperability and consistency detection are required.

Striving to introduce the basics and potentials for ontologies for software language engineering, this tutorial aims to:

1. define ontologies and the OWL language;
2. describe basics of description logics-based reasoning designed for ontology languages;
3. describe the current efforts on relations between the OWL language and languages such as UML, MOF and OCL; and
4. illustrate applications of ontology-enhanced software

languages for software design patterns, software product lines, domain-specific languages, and software language refinement.

After the tutorial, participants will be able (1) to understand the concepts of ontologies, OWL language and its formal reasoning potentials; (2) to realize the valued added by ontology-enabled software languages and (3) to identify potential applications for semantic technologies in software development and different software language engineering approaches other than those based on model-driven engineering principles.

References

[1] Gaševic, Dragan, Djuric, Dragan, Devedžic, Vladan. Model Driven Engineering and Ontology Development. Springer, Berlin, 2. edition, 2009.

[2] F. Silva Parreiras and S. Staab. Using Ontologies with UML Class-based Modeling: The TwoUse Approach. Data Knowl. Eng. in press.

[3] F. Silva Parreiras, S. Staab, and A. Winter. Improving design patterns by description logics: A use case with abstract factory and strategy. In Modellierung 2008, volume P-127 of LNI, pages 89–104. GI, 2008.

[4] W3C OWL Working Group. OWL 2 Web Ontology Language Document Overview. W3C Working Draft 27 March 2009. Available at http://www.w3.org/TR/2009/WD-owl2-overview-20090327//.

[5] T. Walter, F. Silva Parreiras, and S. Staab. OntoDSL: An Ontology-Based Framework for Domain-Specific Languages. In Model Driven Engineering Languages and Systems, 12th International Conference, MODELS 2009, volume 5795, pages 408–422. Springer, 2009.

Author bios

Fernando Silva Parreiras, pursues his PhD since the beginning of 2006 under the supervision of Prof. Steffen Staab. He is the leader of the Special Interest Group Software Web at the Web Science and Technology Institute (WeST) at the University of Koblenz-Landau, Germany. He has been investigating the integration of model-driven engineering and Ontology in the scope of the EU project MOST. His related publications include papers in Modellierung’2008, ER’2008, ICSC’2009, MoDELS’2009 and ECMFA 2010. He has served as program committee member of conferences like SLE and and workshops like ONTOSE and SWESE and as organizer of the TWOMDE workshop.

Dragan Gašević is a Canada Research Chair in Semantic Technologies and an Associate Professor in the School of Computing and Information Systems at Athabasca University. He is also an Adjunct Professor in the School of Interactive Arts and Technology at Simon Fraser University and an associated research member of the GOOD OLD AI Research Network at the University of Belgrade. He is a recipient of Alberta Ingenuity’s 2008 New Faculty Award. His research interests include semantic technologies, software language engineering, technology-enhanced learning, and service-oriented architectures. He has (co-)authored more than 200 research papers and delivered more than 10 tutorials at major conferences such as WWW, MODELS, CAiSE, and ISWC. He has been serving on editorial boards of three international journals and has edited special issues in journals such as IET Software and IEEE TSE. He has been the organizer, chair, and member of program committees of many international conferences.

Tobias Walter is PhD. student at the University of Koblenz-Landau under the supervision of Prof. Dr. Jürgen Ebert and Prof. Dr. Steffen Staab. Currently he is member of the Institute for Software Technology and the Institute for Web Science and Technology. Here, his research focuses on the combination of domain-specific modeling languages and different ontology technologies. Further he is interested in the design and use of new software modelling languages and its implementation in tools. From 2008 he is contributing to the MOST project where he is investigating the conceptual integration of Model-Driven Architecture (MDA) and Ontologies. His related publications include papers at MoDELS’2009, ECMFA’2010, WC-DSL’2009, ICSC’2009 and different workshops.

Download slides as pdf.

Language Definition and Extension with MPS

Markus Völter

Abstract

Language definition and extension is a hot topic. Using modular languages, where a program can use concepts from different language modules as needed, promises significantly increased language usability as well as an integration between general purpose (programming) and domain-specific (modeling) concepts and tools.

JetBrains MPS is an open source language workbench that uses projectional editing as opposed to parsing techniques. In MPS, languages are defined via structure, projection rules, transformation rules and type systems.

In this tutorial I will provide a brief overview about how MPS works and what you can do with it. I will show how to build an external DSL, how to integrate the external DSL with Java, and how to extend an existing programming language with a new statement. To round it off, I will demo a non-trivial set of languages for embedded software development. 90% of the tutorial will be live demos.

Note that even if you don't plan to work with MPS specifically, this tutorial will provide a good overview of projectional editing.

Author biography

Markus Völter works as an independent researcher, consultant and coach for itemis AG in Stuttgart, Germany. His focus is on software architecture, model-driven software development and domain specific languages as well as on product line engineering. Markus also regularly writes (articles, patterns, books) and speaks (trainings, conferences) on those subjects. Contact him via voelter@acm@org or www.voelter.de.

Download slides as pdf.

Conference Header	26 Nov 2010 - 14:52	Eelco Visser
Tutorial 6 MPS	21 Oct 2010 - 13:43	Rob Economopoulos
Web News	21 Oct 2010 - 13:41	Rob Economopoulos
Conference Program	21 Oct 2010 - 13:40	Rob Economopoulos
Tutorial 1 Project Fortress	19 Oct 2010 - 09:07	Rob Economopoulos
Tutorial 5 Ontologies And SE	18 Oct 2010 - 20:14	Rob Economopoulos
Tutorial 3 Embedded DSLs	18 Oct 2010 - 14:24	Rob Economopoulos
Tutorial 2 Mega Medeling	18 Oct 2010 - 14:23	Rob Economopoulos
Tutorial 4 Agile Efficient DSLs	18 Oct 2010 - 14:08	Rob Economopoulos
Web Home	13 Oct 2010 - 12:08	Rob Economopoulos
Conference Registration	03 Sep 2010 - 07:58	Rob Economopoulos
JEquality Gen Generating Equality And Hashing...	31 Aug 2010 - 09:41	Rob Economopoulos
Incremental Type-CheckingForType-Reflecti...	31 Aug 2010 - 09:39	Rob Economopoulos
Model Based Kinematics Generation For Modular...	31 Aug 2010 - 09:37	Rob Economopoulos
ABICompatibility Through ACustomizable Lang...	31 Aug 2010 - 09:35	Rob Economopoulos
Domain Specific Language Integration With Com...	31 Aug 2010 - 09:34	Rob Economopoulos
Lightweight Modular Staging APragmatic Appro...	31 Aug 2010 - 09:32	Rob Economopoulos
Applications Of Dynamic Code Evolution For Jav...	31 Aug 2010 - 09:32	Rob Economopoulos
Composition Of Dynamic Analysis Aspects	31 Aug 2010 - 09:26	Rob Economopoulos
Code Clones In Feature Oriented Software Produ...	31 Aug 2010 - 09:24	Rob Economopoulos
Iterative Type Inference With Attribute Gramm...	27 Aug 2010 - 10:13	Rob Economopoulos
Adding Genericity To APlugin Framework	27 Aug 2010 - 10:11	Rob Economopoulos
Modular Domain Specific Language Components I...	27 Aug 2010 - 10:10	Rob Economopoulos
AComponentbased Runtime Evolution Infrastru...	27 Aug 2010 - 10:09	Rob Economopoulos
Implicit Invocation Meets Safe Implicit Concu...	27 Aug 2010 - 10:08	Rob Economopoulos
Automatic And Efficient Simulation Of Operati...	27 Aug 2010 - 10:07	Rob Economopoulos
Efficient Extraction And Analysis Of Preproce...	27 Aug 2010 - 10:06	Rob Economopoulos
Automatic Variation Point Identification In F...	27 Aug 2010 - 10:05	Rob Economopoulos
Abstract Delta Modeling	27 Aug 2010 - 09:59	Rob Economopoulos
Accepted Papers	20 Aug 2010 - 16:36	Rob Economopoulos
Ralf Laemmel Invited Talk	18 Aug 2010 - 12:14	Rob Economopoulos
Keynote Speakers	18 Aug 2010 - 12:02	Rob Economopoulos
Martin Erwig Invited Talk	13 Aug 2010 - 12:40	Jaakko Jarvi
Web Left Bar	12 Aug 2010 - 07:32	Jaakko Jarvi
Conference Venue	14 Jul 2010 - 12:55	Rob Economopoulos
Call For Tutorials	24 Jun 2010 - 13:55	Rob Economopoulos
Contributor Logos	22 Jun 2010 - 11:14	Rob Economopoulos
Important Dates	14 Jun 2010 - 08:52	Eelco Visser
Web Preferences	27 May 2010 - 03:36	Jaakko Jarvi
Call For Papers	19 May 2010 - 15:30	Jaakko Jarvi
Poster	19 Apr 2010 - 08:47	Rob Economopoulos
Conference Organization	16 Mar 2010 - 09:19	Rob Economopoulos
Web Custom Menus	19 Feb 2010 - 08:59	Eelco Visser
Web Statistics	07 Feb 2010 - 19:42	Janis Voigtlaender
Web Notify	22 Jul 2007 - 23:56	Robert Glueck
Web Changes	05 Dec 2004 - 11:28	Martin Bravenboer
Web Index	23 Jan 2002 - 14:20	Eelco Visser
Web Tools	08 Nov 2001 - 09:49	TWiki Guest
Web Search	08 Aug 2001 - 05:26	Peter Thoeny

Number of topics: 49

---

Ninth International Conference on

Generative Programming and Component Engineering (GPCE'10)

October 10-13, 2010
Eindhoven, The Netherlands
(co-located with SLE 2010)

Sponsored by ACM SIGPLAN.
GPCE'10 proceedings published by ACM Press.
GPCE'10 on twitter: https://twitter.com/gpceconf

---

Generative and component approaches are revolutionizing software development similar to how automation and components revolutionized manufacturing. Generative Programming (developing programs that synthesize other programs), Component Engineering (raising the level of modularization and analysis in application design), and Domain-Specific Languages (elevating program specifications to compact domain-specific notations that are easier to write, maintain, and analyze) are key technologies for automating program development.

GPCE provides a venue for researchers and practitioners interested in foundational techniques for enhancing the productivity, quality, and time-to-market in software development that stems from deploying standard components and automating program generation. In addition to exploring cutting-edge techniques for developing generative and component-based software, our goal is to foster further cross-fertilization between the software engineering research community and the programming languages community.

GPCE variables:

• Set URLGPCE10 = http://gpce10.gpce.org
• Set GPCEDAYS = October 10-13, 2010
• Set GPCEDETAILDAYS = Main Conference: Oct. 11-12, workshops and tutorials: Oct. 10

• Set URLFLYER =
• Set URLFLYERALT = ?
• Set URLOOPSLA06 = ?
• Set URLLOCAL = ?
• Set URLPORTLAND = ?
• Set VENUE = ?
• Set VENUECITY = Eindhoven, The Netherlands

• Set PROPOSALSUBMISSION = ?
• Set PROPOSALNOTIFICATION = ?

• Set PAPERPRESUBMISSION = Wednesday, May 26, 23:59:59, Apia time
• Set PAPERSUBMISSION = Sunday, May 30, 23:59:59, Apia time
• Set PAPERSUBMISSIONPOSTPONED = ?
• Set PAPERNOTIFICATION = July 5, 2010
• Set PAPERCAMERAREADY = ?

• Set WORKSHOPSUBMISSION = *??, * (suggested)
• Set WORKSHOPNOTIFICATION = *??, * (suggested)
• Set WORKSHOPCAMERAREADY = *??, *
• Set TUTORIALCAMERAREADY = *??, *

• Set EARLYREGISTRATION = *??, *
• Set LATEREGISTRATION = *??, *

• Set WORKSHOPDAYS = ?

• Set GPCEVENUE = Gpce Venue

Preferences:

• Set WEBTITLE = Generative Programming and Component Engineering
• Set SHORTWEBTITLE = GPCE 2010

• List of topics of the TWiki.GPCE10 web:
  • Set WEBTOPICLIST = Home | Changes | Index | Search | Go

• Web specific background color: (Pick a lighter one of the StandardColors)
  • Set WEBBGCOLOR = #D0D0D0

• Exclude web from a web="all" search: (Set to on for hidden webs)
  • Set NOSEARCHALL =

• Default template for new topics and form(s) for this web:
  • WebTopicEditTemplate^?: Default template for new topics in this web. (Site-level is used if topic does not exist)
  • TWiki.WebTopicEditTemplate: Site-level default template
  • TWikiForms: How to enable form(s)
  • Set WEBFORMS =

• Users or groups who are not / are allowed to view / change / rename topics in the GPCE10 web: (See TWikiAccessControl)
  • Set DENYWEBVIEW =
  • Set ALLOWWEBVIEW =
  • Set DENYWEBCHANGE =
  • Set ALLOWWEBCHANGE = GpceorgGroup
  • Set DENYWEBRENAME =
  • Set ALLOWWEBRENAME = GpceorgGroup

• Users or groups allowed to change or rename this WebPreferences topic: (I.e. TWikiAdminGroup)
  • Set ALLOWTOPICCHANGE = TWikiAdminGroup GpceorgGroup
  • Set ALLOWTOPICRENAME = TWikiAdminGroup GpceorgGroup

• Web preferences that are not allowed to be overridden by user preferences:
  • Set FINALPREFERENCES = WEBTOPICLIST, DENYWEBVIEW, ALLOWWEBVIEW, DENYWEBCHANGE, ALLOWWEBCHANGE, DENYWEBRENAME, ALLOWWEBRENAME

Notes:

• A preference is defined as:
  6 spaces * Set NAME = value
  Example:
  • Set WEBBGCOLOR = #FFFFC0
• Preferences are used as TWikiVariables by enclosing the name in percent signs. Example:
  • When you write variable %WEBBGCOLOR% , it gets expanded to #D0D0D0 .
• The sequential order of the preference settings is significant. Define preferences that use other preferences first, i.e. set WEBCOPYRIGHT before WIKIWEBMASTER since %WEBCOPYRIGHT% uses the %WIKIWEBMASTER% variable.
• You can introduce new preferences variables and use them in your topics and templates. There is no need to change the TWiki engine (Perl scripts).

Related Topics:

• TWikiPreferences has site-level preferences.
• TWikiUsers has a list of user topics. User topics can have optional user preferences.
• TWikiVariables has a list of common %VARIABLES%.
• TWikiAccessControl explains how to restrict access by users or groups.

All public webs	Help Advanced search?
Text body   Topic title   Both

• Topic index: List of GPCE10 topics in alphabetical order.
  |All|A|B|C|D|E|F|G|H|I|J|K|L|M|N|O|P|Q|R|S|T|U|V|W|X|Y|Z|
  | All topics in BookView |

• Jump to topic: If you already know the name of the topic, enter the name of the topic into the GoBox at the top

• WebChanges: Find out what topics in GPCE10 have changed recently

• How to edit text:
  • Make changes to topics in GoodStyle,
  • Learn the TextFormattingRules, and
  • Have a look at the TextFormattingFAQ

HistoricalStatistics^? for TWiki.GPCE10 Web

Month:	Topic views:	Topic saves:	File uploads:	Most popular topic views:	Top contributors for topic save and uploads:
Feb 2008	2643	0	0	512 WebStatistics 302 WebHome 103 WebPreferences 102 WebNews 102 PEPMPublicity? 102 PEPMProgram?  75 ProgramCommittee?  70 CallForPapers  63 PaperSubmission?  63 ImportantDates  63 PreviousMeetings?
Jan 2008	9554	0	0	1433 WebHome 786 WebStatistics 660 PEPMProgram? 433 ProgramCommittee? 361 PEPMPublicity? 291 WebNews 283 PreviousMeetings? 283 RegistrationAndAccomodation? 265 PaperSubmission? 265 ImportantDates 260 InvitedTalks?
Dec 2007	7197	33	0	1314 WebHome 573 PEPMProgram? 329 WebStatistics 304 ProgramCommittee? 267 WebNews 254 PEPMPublicity? 233 AcceptedPapers 213 PaperSubmission? 204 InvitedTalks? 201 RegistrationAndAccomodation? 195 PreviousMeetings?	32 RobertGlueck   1 OegeDeMoor
Nov 2007	8164	17	0	1673 WebHome 430 WebStatistics 374 AcceptedPapers 344 ImportantDates 335 ProgramCommittee? 300 WebNews 275 PEPMProgram? 267 RegistrationAndAccomodation? 266 PaperSubmission? 255 InvitedTalks? 247 PEPMPublicity?	17 RobertGlueck
Oct 2007	8900	21	1	2412 WebHome 822 PaperSubmission? 709 ImportantDates 565 CallForPapers 440 ProgramCommittee? 369 ResearchPaperAdvice? 232 ToolPaperAdvice? 217 PEPMPublicity? 197 InvitedTalks? 196 WebNews 196 PreviousMeetings?	22 RobertGlueck
Sep 2007	7368	3	0	1582 WebHome 443 CallForPapers 404 ImportantDates 375 PaperSubmission? 358 ProgramCommittee? 332 WebStatistics 254 PEPMPublicity? 236 PreviousMeetings? 228 ResearchPaperAdvice? 200 InvitedTalks? 198 RegistrationAndAccomodation?	3 RobertGlueck
Aug 2007	12282	74	10	2082 WebHome 833 ProgramCommittee? 744 WebStatistics 741 CallForPapers 573 ImportantDates 513 PEPMPublicity? 433 PaperSubmission? 416 PEPMProgram? 409 PreviousMeetings? 383 ResearchPaperAdvice? 341 ConferenceOrganization	81 RobertGlueck   3 OegeDeMoor
Jul 2007	3115	144	0	405 WebHome 216 ProgramCommittee? 159 PreviousMeetings? 154 CallForPapers 150 WebStatistics 132 ImportantDates 117 PEPMNews? 112 WebIndex  99 PEPMPublicity?  96 ConferenceOrganization  80 ResearchPaperAdvice?	144 RobertGlueck
Jun 2007	5518	0	0	673 WebHome 316 WebStatistics 235 PEPMProgram? 172 PreviousMeetings? 154 WebNews 153 WorkshopVenue? 146 ProgramCommittee? 142 PaperSubmission? 134 PEPMPublicity? 131 AffiliatedMeetings? 130 AcceptedPapers
May 2007	4489	0	0	530 WebHome 524 WebStatistics 202 PEPMProgram? 126 PEPMPublicity? 116 WebNews 115 PreviousMeetings? 113 ProgramCommittee? 110 PaperSubmission? 107 RegistrationAndAccomodation?  98 AffiliatedMeetings?  98 WorkshopVenue?
Apr 2007	4460	0	0	606 WebHome 358 WebStatistics 172 PEPMProgram? 135 ProgramCommittee? 121 WebNews 121 PEPMPublicity? 121 ToolPaperAdvice? 119 PreviousMeetings? 115 CallForPapers 109 PaperSubmission? 105 WebChanges
Mar 2007	4825	0	0	593 WebHome 454 WebStatistics 202 PEPMProgram? 152 ProgramCommittee? 128 WebNews 118 PublicityList06? 116 PaperSubmission? 110 AffiliatedMeetings? 109 ResearchPaperAdvice? 108 WebChanges 103 PreviousMeetings?
Feb 2007	4464	0	0	661 WebHome 344 WebStatistics 261 PEPMProgram? 158 WebNews 158 ProgramCommittee? 128 PaperSubmission? 123 AffiliatedMeetings? 119 ResearchPaperAdvice? 118 CallForPapers 116 PEPMPublicity? 108 ToolPaperAdvice?
Jan 2007	5169	7	0	1040 WebHome 612 WebStatistics 462 PEPMProgram? 188 ProgramCommittee? 148 WebNews 133 PEPMPublicity? 123 AffiliatedMeetings? 114 CallForPapers 113 AcceptedPapers 112 PaperSubmission? 111 ResearchPaperAdvice?	7 EelcoVisser
Dec 2006	4452	17	0	1122 WebHome 398 PEPMProgram? 164 ProgramCommittee? 140 AcceptedPapers 134 RegistrationAndAccomodation? 126 ResearchPaperAdvice? 118 WebStatistics 115 ImportantDates 114 CallForPapers 101 WebNews  98 ToolPaperAdvice?	17 EelcoVisser
Nov 2006	3436	5	0	782 WebHome 223 WebStatistics 154 ProgramCommittee? 141 ImportantDates 136 ResearchPaperAdvice? 125 CallForPapers 106 ToolPaperAdvice?  97 PEPMProgram?  88 AffiliatedMeetings?  88 InvitedTalks?  83 PEPMPublicity?	5 EelcoVisser
Oct 2006	3880	8	0	1065 WebHome 262 ImportantDates 252 CallForPapers 201 PaperSubmission? 162 ProgramCommittee? 134 ResearchPaperAdvice? 121 WebStatistics 111 PEPMPublicity? 101 PreviousMeetings?  91 ToolPaperAdvice?  91 AffiliatedMeetings?	8 EelcoVisser
Sep 2006	2926	5	0	650 WebHome 176 CallForPapers 146 ImportantDates 136 WebStatistics 116 ProgramCommittee?  95 ResearchPaperAdvice?  82 PEPMPublicity?  76 InvitedTalks?  72 PaperSubmission?  69 PreviousMeetings?  67 ToolPaperAdvice?	5 EelcoVisser
Aug 2006	4938	0	0	786 WebHome 268 CallForPapers 213 WebStatistics 195 ProgramCommittee? 176 PaperSubmission? 171 WebChanges 155 ImportantDates 151 PEPMPublicity? 148 PreviousMeetings? 131 WebNotify 124 PEPMProgram?
Jul 2006	7014	0	0	868 WebHome 350 ProgramCommittee? 337 WebStatistics 334 CallForPapers 235 PaperSubmission? 213 PreviousMeetings? 206 PEPMPublicity? 194 ImportantDates 189 WebChanges 180 WebNotify 175 RegistrationAndAccomodation?
Jun 2006	4150	29	2	827 WebHome 261 CallForPapers 233 ProgramCommittee? 164 WebStatistics 159 ImportantDates 136 PreviousMeetings? 125 ResearchPaperAdvice? 119 PaperSubmission? 116 WebChanges 114 PEPMPublicity? 104 RegistrationAndAccomodation?	31 EelcoVisser
May 2006	2620	80	0	427 WebHome 138 ProgramCommittee? 138 CallForPapers 103 PreviousMeetings? 103 ImportantDates  78 WorkshopVenue?  77 ResearchPaperAdvice?  74 WebChanges  72 WebLeftBar  69 WebNotify  69 AffiliatedMeetings?	80 EelcoVisser
Apr 2006	15023	8	0	3330 WebHome 1250 CallForPapers 781 WebStatistics 571 ImportantDates 504 ConferenceOrganization 486 CallForTutorials 468 CallForDemonstrations? 443 CallForWorkshops? 414 WebNews 397 ElectronicSubmission? 393 WebChanges	8 ToddVeldhuizen
Mar 2006	10528	1	0	2345 WebHome 871 CallForPapers 667 WebStatistics 376 ImportantDates 343 CallForTutorials 325 CallForWorkshops? 325 ConferenceOrganization 310 WebNews 263 CallForDemonstrations? 255 WebChanges 244 WebPreferences	1 EelcoVisser
Feb 2006	6534	0	0	1541 WebHome 550 CallForPapers 397 WebStatistics 258 ImportantDates 235 CallForTutorials 226 ConferenceOrganization 215 CallForDemonstrations? 212 CallForWorkshops? 200 WebNews 139 WebLeftBar 129 WebPreferences
Jan 2006	6593	129	5	1553 WebHome 494 CallForPapers 422 WebStatistics 315 ImportantDates 240 WebNews 223 ConferenceOrganization 219 CallForTutorials 197 WebPreferences 191 CallForWorkshops? 187 WebLeftBar 152 WebChanges	116 EmirPasalic  17 ToddVeldhuizen   1 ChristaSchwanninger
Dec 2005	5873	38	0	1603 WebHome 535 WebStatistics 292 WebNews 246 CallForPapers 230 WebLeftBar 204 WebPreferences 194 ImportantDates 179 ConferenceHeader 166 WebIndex 160 CallForTutorials 156 PEPMNews?	37 EmirPasalic   1 ChristaSchwanninger
Nov 2005	3943	0	0	868 WebStatistics 849 WebHome 147 WebLeftBar 144 WebNews 127 ImportantDates 126 WebPreferences 116 WebChanges 114 CallForPapers 109 ConferenceOrganization 105 WebNotify  92 PEPMNews?
Oct 2005	3209	33	0	932 WebHome 175 WebNews 127 WebChanges 126 WebPreferences 118 PEPMNews? 115 WebLeftBar 111 ImportantDates 110 WebNotify 105 WebStatistics 101 ConferenceHeader  99 WebIndex	31 ChristaSchwanninger   2 EugenioMoggi
Sep 2005	1290	18	2	361 WebHome  73 WebNews  55 WebIndex  46 WebNotify  46 WebChanges  41 PEPMNews?  39 WebChanges500?  38 WebSearch  38 CallForPapers  37 WebPreferences  36 WebChanges100?	17 EelcoVisser   3 PradeepikaIrangani
Aug 2005	1526	32	1	481 WebHome 147 WebStatistics  94 ConferenceHeader  86 WebIndex  84 WebNews  75 WebPreferences  69 WebChanges  59 PEPMNews?  51 WebNotify  49 WebLeftBar  43 WebSearch	20 EelcoVisser   7 MartinBravenboer   5 StanJarzabek   1 PradeepikaIrangani
Jul 2005	1191	0	0	389 WebHome 102 WebNews  74 WebIndex  73 WebChanges  68 WebStatistics  67 PEPMNews?  57 ConferenceHeader  52 WebSearch  50 WebNotify  50 WebChanges500?  49 WebChanges200?
Jun 2005	923	0	0	375 WebHome  86 WebNews  68 WebStatistics  57 WebChanges  46 PEPMNews?  45 WebNotify  42 WebIndex  39 WebSearch  37 ConferenceHeader  26 WebLeftBar  24 WebChanges500?
May 2005	848	7	0	371 WebHome  53 WebNews  51 WebStatistics  45 ConferenceHeader  42 PEPMNews?  38 WebChanges  33 WebIndex  31 WebSearch  26 WebPreferences  24 WebNotify  24 WebLeftBar	7 EelcoVisser
Apr 2005	6648	36	0	2409 WebHome 975 CallForPapers 638 ElectronicSubmission? 298 GpceTutorialsAndWorkshops? 242 ImportantDates 181 ConferenceOrganization 148 CallForDemonstrations? 130 CallForWorkshops? 110 YoungResearchers? 102 GraphModelTransformations?  93 CallForTutorials	23 AndrewMalton  10 EugenioMoggi   2 RobertGlueck   1 EelcoVisser
Mar 2005	4848	35	1	2091 WebHome 696 CallForPapers 202 ImportantDates 178 ElectronicSubmission? 153 ConferenceOrganization 152 CallForDemonstrations? 132 CallForWorkshops? 131 GpceTutorialsAndWorkshops? 106 CallForTutorials  55 PEPMNews?  52 WebIndex	29 EugenioMoggi   5 RobertGlueck   2 EelcoVisser
Feb 2005	2975	7	0	1164 WebHome 364 CallForPapers 140 ImportantDates 137 ConferenceOrganization  95 CallForWorkshops?  84 CallForDemonstrations?  72 CallForTutorials  50 PEPMNews?  39 WebNews  39 WebChanges  38 WebNotify	7 EugenioMoggi
Jan 2005	2719	19	0	1375 WebHome 211 CallForPapers 169 ConferenceOrganization 135 ImportantDates  98 CallForWorkshops?  74 CallForTutorials  59 PEPMNews?  45 WebIndex  42 WebChanges  35 WebNews  30 CallForDemonstrations?	12 EugenioMoggi   7 EelcoVisser
Dec 2004	1546	68	0	707 WebHome 125 ImportantDates  92 ConferenceOrganization  67 ConferenceVenue  60 CallForWorkshops?  37 WebIndex  36 CallForTutorials  34 WebPreferences  33 WebNews  32 PEPMNews?  25 WebChanges	43 EugenioMoggi  13 JeffGray  10 EelcoVisser   2 MartinBravenboer
Nov 2004	836	18	0	407 WebHome  77 ImportantDates  66 ConferenceOrganization  38 ConferenceVenue  31 PEPMNews  28 CallForPapers  25 WebNews  20 ForOrganizers?  19 WebIndex   9 CallForWorkshops?   8 ElectronicSubmission?	11 EelcoVisser   7 EugenioMoggi
Oct 2004	400	30	0	206 WebHome  50 ConferenceOrganization  38 ImportantDates  27 ConferenceVenue  17 ConferenceHeader  14 WebIndex  11 WebContents?   5 PrintCall?   4 WebNews   4 CallForPapers   2 GpceTutorials?	27 EugenioMoggi   2 MoggiE   1 RobertGlueck

Notes:

• Do not edit this topic, it is updated automatically. (You can also force an update)
• TWikiDocumentation tells you how to enable the automatic updates of the statistics.
• Suggestion: You could archive this topic once a year and delete the previous year's statistics from the table.

Finding topics

• RoadMap^?
• WebIndex: all topics in the GPCE10 web
• WebSearch: find topics

Tracking activity

• WebNews: selected changes
• WebChanges: recent changes
• WebNotify: email notification of changes
• WebStatistics: usage counts

Look and feel

• WebPreferences: values of variables
• WebContents^?: web specific entries in the side bar